package com.mf.ergate.web.service.auth.impl;

import com.mf.ergate.api.auth.RoleInfoRemoteService;
import com.mf.ergate.api.auth.model.dto.*;
import com.mf.ergate.api.auth.model.vo.ResourceInfoVo;
import com.mf.ergate.api.auth.model.vo.RoleInfoVo;
import com.mf.ergate.api.auth.model.vo.RoleResourceRelationVo;
import com.mf.ergate.api.auth.model.vo.RoleUserRelationVo;
import com.mf.ergate.web.domain.enums.auth.RoleTypeEnum;
import com.mf.ergate.web.service.auth.*;
import com.mf.framework.common.model.Page;
import com.mf.framework.common.model.RemotePage;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.HashSet;
import java.util.List;
import java.util.Objects;
import java.util.Set;

/**
* 角色信息Service层实现类
* User: zhaoming
* DateTime: 2019-02-12
* To change this template use File | Settings | File Templates.
**/
@Service
public class RoleInfoServiceImpl implements RoleInfoService {

    private Logger logger = LoggerFactory.getLogger(getClass());

    @Autowired
    private RoleInfoRemoteService roleInfoRemoteService;
    @Autowired
    private RoleUserRelationService roleUserRelationService;
    @Autowired
    private UserInfoService userInfoService;
    @Autowired
    private RoleResourceRelationService roleResourceRelationService;
    @Autowired
    private ResourceInfoService resourceInfoService;

    /**
     * 新增
     * @param roleInfoCreateDto 角色信息新增Dto
     * @return 角色信息
     */
    public RoleInfoVo insert(RoleInfoCreateDto roleInfoCreateDto){
        return roleInfoRemoteService.insert(roleInfoCreateDto).getContent();
    }

    /**
     * 根据唯一编号更新
     * @param roleInfoUpdateDto 角色信息更新Dto
     * @return 执行结果
     */
    public Boolean updateByUniqueNo(RoleInfoUpdateDto roleInfoUpdateDto){
        return roleInfoRemoteService.updateByUniqueNo(roleInfoUpdateDto).getContent();
    }

    /**
     * 根据唯一编号删除(逻辑删除)
     * @param roleInfoDeleteDto 角色信息删除Dto
     * @return 执行结果
     */
    public Boolean deleteByUniqueNo(RoleInfoDeleteDto roleInfoDeleteDto){
        return roleInfoRemoteService.deleteByUniqueNo(roleInfoDeleteDto).getContent();
    }

    /**
     * 根据唯一编号查询
     * @param roleInfoNo 角色信息编号
     * @return 角色信息
     */
    public RoleInfoVo selectByUniqueNo(String roleInfoNo){
        return roleInfoRemoteService.selectByUniqueNo(roleInfoNo).getContent();
    }

    /**
     * 根据条件查询
     * @param roleInfoQueryDto 角色信息查询Dto
     * @return 角色信息列表
     */
    public List<RoleInfoVo> selectByCondition(RoleInfoQueryDto roleInfoQueryDto){
        return roleInfoRemoteService.selectByCondition(roleInfoQueryDto).getContent();
    }

    /**
     * 根据条件查询数量
     * @param roleInfoQueryDto 角色信息查询Dto
     * @return 数量
     */
    public Integer selectCount(RoleInfoQueryDto roleInfoQueryDto){
        return roleInfoRemoteService.selectCount(roleInfoQueryDto).getContent();
    }

    /**
     * 根据条件分页查询
     * @param page 远程分页
     * @param roleInfoQueryDto 角色信息查询Dto
     * @return 角色信息分页列表
     */
    public Page<RoleInfoVo> selectPage(Page page, RoleInfoQueryDto roleInfoQueryDto){
        return roleInfoRemoteService.selectPage(new RemotePage<>(roleInfoQueryDto, page)).getContent();
    }

    /**
     * 删除角色及相关信息(逻辑删除)
     * @param roleInfoDeleteDto 角色信息删除Dto
     * @return 执行结果
     */
    public Boolean deleteCompleteByUniqueNo(RoleInfoDeleteDto roleInfoDeleteDto){
        return roleInfoRemoteService.deleteCompleteByUniqueNo(roleInfoDeleteDto).getContent();
    }

    /**
     * 角色与用户关联分页查询
     * @param page 分页实体
     * @param roleUserRelationQueryDto 用户与角色关联查询Dto
     * @return 角色与用户关联分页列表
     */
    public Page<RoleUserRelationVo> roleUserRelationPage(Page page, RoleUserRelationQueryDto roleUserRelationQueryDto){
        Page<RoleUserRelationVo> roleUserRelationPage = roleUserRelationService.selectPage(page, roleUserRelationQueryDto);
        for(RoleUserRelationVo roleUserRelationVo : roleUserRelationPage.getContent()){
            RoleInfoVo roleInfoVo = this.selectByUniqueNo(roleUserRelationVo.getRoleNo());
            if(Objects.equals(roleInfoVo.getRoleTypeCode(), RoleTypeEnum.ROLE_MANAGE.getIndex())){
                //管理用户
                roleUserRelationVo.setUserInfoVo(userInfoService.selectByUniqueNo(roleUserRelationVo.getUserNo()));
            }else if(Objects.equals(roleInfoVo.getRoleTypeCode(), RoleTypeEnum.ROLE_OPERATE.getIndex())){
                //TODO 运营用户
            }else if(Objects.equals(roleInfoVo.getRoleTypeCode(), RoleTypeEnum.ROLE_SELLER.getIndex())){
                //TODO 商家用户
            }
            roleUserRelationVo.setRoleInfoVo(roleInfoVo);
        }
        return roleUserRelationPage;
    }

    /**
     * 根据条件查询资源列表
     * @param roleResourceRelationQueryDto 角色与资源关联查询Dto
     * @return 资源列表
     */
    public List<ResourceInfoVo> listResource(RoleResourceRelationQueryDto roleResourceRelationQueryDto){
        Set<String> resourceCodeSet = new HashSet<>();
        List<RoleResourceRelationVo> roleResourceRelationVos = roleResourceRelationService.selectByCondition(roleResourceRelationQueryDto);
        for (RoleResourceRelationVo roleResourceRelationVo : roleResourceRelationVos) {
            resourceCodeSet.add(roleResourceRelationVo.getResourceNo());
        }
        List<ResourceInfoVo> resourceInfoVos = resourceInfoService.selectByCondition(new ResourceInfoQueryDto());
        for (ResourceInfoVo resourceInfoVo : resourceInfoVos) {
            if (resourceCodeSet.contains(resourceInfoVo.getUniqueNo())) {
                resourceInfoVo.setChecked(true);
            }
        }
        return resourceInfoVos;
    }

    /**
     * 保存角色与资源关联信息
     * @param roleResourceRelationCreateDtos 角色与资源关联新增Dto列表
     * @return 执行结果
     */
    public Boolean saveRoleResourceRelation(List<RoleResourceRelationCreateDto> roleResourceRelationCreateDtos){
        return roleResourceRelationService.save(roleResourceRelationCreateDtos);
    }

}
